import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, Session
from src.models.database.models import Base, Plate, Position
from src.core.config import config
from src.core.path_manager import path_manager

class DatabaseManager:
    def __init__(self, init_data=None):
        """
        初始化数据库管理器
        
        Args:
            init_data: 数据初始化选项
                - None: 根据配置决定是否初始化数据
                - True: 强制初始化默认数据
                - False: 只创建表结构，不初始化数据
                - "clean": 创建干净的数据库（只有表结构）
        """
        # 确保数据库路径是绝对路径
        db_path = config.database_path
        if not os.path.isabs(db_path):
            db_path = str(path_manager.get_database_file())
            
        self.database_url = f"sqlite:///{db_path}"
        self.engine = None
        self.SessionLocal = None
        self.init_data_option = init_data
        self.init_database()
    
    def init_database(self):
        """初始化数据库"""
        # 确保数据目录存在
        db_path = config.database_path
        if not os.path.isabs(db_path):
            db_path = str(path_manager.get_database_file())
            
        # 确保数据库目录存在
        db_dir = os.path.dirname(db_path)
        if db_dir:
            os.makedirs(db_dir, exist_ok=True)
        
        # 创建数据库引擎
        self.engine = create_engine(
            self.database_url,
            connect_args={"check_same_thread": False}  # SQLite特殊配置
        )
        
        # 创建会话工厂
        self.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=self.engine)
        
        # 创建所有表
        Base.metadata.create_all(bind=self.engine)
        
        # 根据选项决定是否初始化数据
        if self.init_data_option is None:
            # 默认行为：检查配置
            if config.get("init_default_data", True):
                self.init_default_data()
        elif self.init_data_option is True:
            # 强制初始化数据
            self.init_default_data()
        elif self.init_data_option == "clean" or self.init_data_option is False:
            # 创建干净的数据库，不初始化数据
            print("创建干净的数据库（仅表结构）")
    
    def get_session(self) -> Session:
        """获取数据库会话"""
        return self.SessionLocal()
    
    def init_default_data(self):
        """初始化默认料盘数据"""
        session = self.get_session()
        try:
            # 检查是否已有数据
            existing_plates = session.query(Plate).count()
            if existing_plates > 0:
                print("数据库已有数据，跳过初始化")
                return
            
            # 创建默认料盘
            default_plates = config.get("default_plates", [])
            for plate_config in default_plates:
                plate = Plate(
                    name=plate_config["name"],
                    capacity=plate_config["capacity"]
                )
                session.add(plate)
                session.flush()  # 获取plate.id
                
                # 为每个料盘创建料位
                for i in range(plate.capacity):
                    position = Position(
                        plate_id=plate.id,
                        position_index=i,
                        sample_id="",
                        status="available",
                        task_id="",
                        task_type="init",
                        operator="system"
                        # operation_time 使用默认值 datetime.now
                    )
                    session.add(position)
            
            session.commit()
            print("默认料盘数据初始化完成")
            
        except Exception as e:
            session.rollback()
            print(f"初始化默认数据失败: {e}")
        finally:
            session.close()
    
    def create_clean_database(self):
        """创建干净的数据库（仅表结构，无数据）"""
        if self.engine:
            # 删除所有表
            Base.metadata.drop_all(bind=self.engine)
            # 重新创建表结构
            Base.metadata.create_all(bind=self.engine)
            print("创建干净的数据库完成（仅表结构）")
    
    def reset_database(self):
        """重置数据库"""
        if self.engine:
            Base.metadata.drop_all(bind=self.engine)
            Base.metadata.create_all(bind=self.engine)
            self.init_default_data()
    
    def clear_all_data(self):
        """清空所有数据，保留表结构"""
        session = self.get_session()
        try:
            # 删除所有料位数据
            session.query(Position).delete()
            # 删除所有料盘数据
            session.query(Plate).delete()
            session.commit()
            print("所有数据已清空")
        except Exception as e:
            session.rollback()
            print(f"清空数据失败: {e}")
        finally:
            session.close()
    
    def dispose(self):
        """释放数据库连接"""
        if self.engine:
            self.engine.dispose()
            print("数据库连接已释放")

# 全局数据库管理器实例 - 延迟初始化
_db_manager = None

def get_db_manager():
    """获取全局数据库管理器实例（延迟初始化）"""
    global _db_manager
    if _db_manager is None:
        _db_manager = DatabaseManager()
    return _db_manager

# 为了向后兼容，保留db_manager属性
class _DBManagerProxy:
    """数据库管理器代理，实现延迟初始化"""
    def __getattr__(self, name):
        return getattr(get_db_manager(), name)

db_manager = _DBManagerProxy()

def get_db():
    """依赖注入：获取数据库会话"""
    db = get_db_manager().get_session()
    try:
        yield db
    finally:
        db.close()

def create_clean_db_manager():
    """创建干净的数据库管理器（仅表结构）"""
    return DatabaseManager(init_data="clean")

def dispose_global_db_manager():
    """释放全局数据库管理器连接"""
    global _db_manager
    if _db_manager is not None:
        _db_manager.dispose()
        _db_manager = None
        print("全局数据库管理器已释放") 